home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / tex / asc2word.zip / ASC2WORD.C next >
C/C++ Source or Header  |  1986-11-10  |  6KB  |  195 lines
  1. /* asc2word ("ASCII-to-Word")  Process a normal ASCII text file for use
  2.    with the Microsoft "Word" word processing program.
  3.  
  4. This program takes much of the manual work out of the job of
  5. converting a conventional test file into a file easily editable with
  6. Microsoft Word, by converting carriage return/linefeed combinations
  7. (which are taken to be paragraph boundaries by Word) into either
  8. Word's end-of-line marker (shift-CR in Word), thus preserving line
  9. boundaries, or spaces, thus allowing paragraph filling.
  10.        
  11. The -n option indicates that the document is to be processed
  12. (initially, at least - see ".nf" and ".fi" commands below) with the
  13. "No-fill" option; CR's are converted to end-of-line markers (shift-CR
  14. in Word).  This has the overall effect of preserving the line
  15. boundaries in the original document, but not converting each line to
  16. a paragraph, which adds extra blank lines with many paragraph styles.
  17.  
  18. Without the "-n" option, single CR's are (initially) converted to
  19. spaces, which allows Word to fill all lines in a paragraph according
  20. to the style sheet. 
  21.  
  22. Regardless of the -n option setting, two successive CR's are always
  23. interpreted as a paragraph boundary.
  24.  
  25. The fill/nofill option can changed as needed throughout the document
  26. (to accomodate tables, for example, in the middle of otherwise
  27. fillable text).  To switch to no-fill, insert a line containing only
  28. ".nf" (no quotes) in the document at the appropriate place; the
  29. following text will then be processed by converting CR's to Word
  30. end-of-line markers.  To switch to fill mode, insert a line
  31. containing only ".fi" (no quotes) in the document; the following text
  32. will be processed by converting CR's to spaces.
  33.  
  34. There can be as many ".nf" and ".fi" lines in the document as needed,
  35. in any order, but each must be alone on its own line.
  36.  
  37. Compiled with Microsoft C 3.0.
  38.  
  39. George Marshall  11-10-86
  40.  
  41.     Usage: asc2word [-n] input_file output_file
  42. */
  43.  
  44. #include <stdio.h>
  45. #include <ctype.h>
  46.  
  47. FILE *istream, *ostream;
  48.  
  49. #define    NEWLINE    0x0a
  50. #define TRUE 1
  51. #define FALSE 0
  52.  
  53. #define MAXLINE    512
  54. char    line[MAXLINE]={'A'};        /* the input buffer */
  55.  
  56. int    lastnull=TRUE;
  57.                     /* end-of-line for word (shift-CR) */
  58. #define WORDEOL 0x0b
  59. #define SPACE ' '
  60.  
  61. char    nofill[]={".nf"};
  62. char    yesfill[]={".fi"};
  63. int    fill_sw = TRUE;            /* switch: default is to fill */
  64. int    lineno=0;
  65. int    argn = 0;
  66.  
  67. main (argc, argv)
  68. int argc;
  69. char *argv[];
  70. {
  71.     int    i, maxchar;
  72.                     /* first, get the options and
  73.                     filenames. */
  74.     if (argc == 1) {
  75.         printf ("Usage: asc2word [-n] input_file output_file\n");
  76.         printf ("    -n (optional) means start out as No-fill\n");
  77.         printf ("    (i.e., don't let Word fill in or justify lines\n");
  78.         printf ("    .fi on its own line means start filling\n");
  79.         printf ("    .nf on its own line means start no-fill\n");
  80.         return;
  81.     }
  82.  
  83.     argn = 1;            /* first arg to be examined */
  84.  
  85.     if (*argv[argn] == '-') {
  86.         if (toupper( *(argv[argn]+1) ) == 'N') {
  87.                     /* arg is no-fill option */
  88.             fill_sw = FALSE;
  89.             argn++;
  90.         }
  91.         else {
  92.             printf("Sorry - I don't understand option %s\n",
  93.                 argv[argn]);
  94.             exit(-1);
  95.         }
  96.     }
  97.             
  98.     if ((istream = freopen (argv[argn], "rt", stdin)) == NULL) {
  99.         printf ("I can't find the input file %s", argv[argn]);
  100.         return;
  101.     }
  102.     argn++;
  103.     
  104.     if ((ostream = fopen (argv[argn], "wt")) == NULL) {
  105.         printf ("I can't open the output file %s", argv[argn]);
  106.         fclose (istream);
  107.         return;
  108.     }
  109.  
  110.     while ((fgets (line, MAXLINE, istream)) != (char *)NULL) {
  111.         lineno++;
  112.                         /* get length of line */
  113.         maxchar = strlen(line) - 1;
  114.  
  115.         if (line[maxchar] == NEWLINE) line[maxchar] = 0;
  116.  
  117.         if (strcmp(line, nofill) == 0) {
  118.                             /* found no-fill marker: cease
  119.                         removing CR's in this region:
  120.                         just convert to EOL's */
  121.                         /* were in fill mode - force
  122.                         new paragraph if needed. */
  123.             if (fill_sw == TRUE && !lastnull) putc(NEWLINE, ostream);
  124.             fill_sw = FALSE;
  125.             lastnull = TRUE;
  126.             continue;            /* next line, please */
  127.         }
  128.         if (strcmp(line, yesfill) == 0) {
  129.                             /* found fill marker - turn
  130.                         on filling again, which means
  131.                         all CRs get converted to
  132.                         spaces, unless after another
  133.                         CR to signal end of parag.*/
  134.                         /* were in nofill mode - force
  135.                         new paragraph if needed. */
  136.             if (fill_sw == FALSE && !lastnull) putc(NEWLINE, ostream);
  137.             fill_sw = TRUE;
  138.             lastnull = TRUE;
  139.             continue;
  140.         }
  141.         if ( (maxchar == 0) || (whiteline(line, maxchar) )) {
  142.                             /* terminate last line with 
  143.                         cr/lf if this one is a null
  144.                         line, so Word doc will have 
  145.                         a paragraph marker wherever
  146.                             the original doc had blank
  147.                         lines. */
  148.             putc(NEWLINE, ostream);
  149.             lastnull = TRUE;
  150.         }
  151.         else {
  152.                         /* normal line - write out the
  153.                         line terminator for the last
  154.                         line, and the current line
  155.                         (with no terminator) */
  156.             if (lastnull) 
  157.                 putc(NEWLINE, ostream);
  158.             else {
  159.                 if (fill_sw) putc(SPACE,   ostream);
  160.                 else         putc(WORDEOL, ostream);
  161.             }
  162.                         /* if we are in fill mode,
  163.                         get rid of leading blanks
  164.                         etc for better appearance.*/
  165.             i = 0;
  166.             if (fill_sw) i = first_char(line);
  167.             fprintf(ostream, "%s", &line[i]);
  168.             lastnull = FALSE;
  169.         }
  170.     }
  171.             putc(NEWLINE, ostream);    /* final line terminator */
  172.  
  173. }
  174. whiteline (line, num)
  175. char *line;
  176. int num;
  177. {
  178.                     /* this function returns true if 
  179.                     the line consists only of whitespace:
  180.                     spaces and tabs */
  181.     int i;
  182.     for (i=0; i < num; i++) if (!isspace(line[i])) return(FALSE);
  183.     return (TRUE);
  184. }
  185.  
  186. first_char(line)
  187. char *line;
  188.                     /* return index of first (non-white)
  189.                     printing character */
  190. {
  191.     int i;
  192.     for (i=0 ; line[i] != 0 ; i++) if (!isspace(line[i])) return(i);
  193.     return strlen(line);
  194. }
  195.